home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 3 / Amiga Tools 3.iso / terminal / term / extras / source / gtlayout-source.lha / LT_New.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-25  |  41.2 KB  |  1,935 lines
  1. /*  GadTools layout toolkit
  2. **
  3. **  Copyright © 1993-1995 by Olaf `Olsen' Barthel
  4. **  Freely distributable.
  5. */
  6.  
  7. #include "gtlayout_global.h"
  8.  
  9. VOID __stdargs
  10. LT_Add(LayoutHandle *Handle,UBYTE Type,STRPTR Label,LONG ID,...)
  11. {
  12.     va_list VarArgs;
  13.  
  14.     va_start(VarArgs,ID);
  15.     LT_AddA(Handle,Type,Label,ID,(struct TagItem *)VarArgs);
  16.     va_end(VarArgs);
  17. }
  18.  
  19.  
  20. /*****************************************************************************/
  21.  
  22.  
  23. VOID LIBENT
  24. LT_AddA(REG(a0) LayoutHandle *Handle,REG(d0) UBYTE Type,REG(d1) STRPTR Label,REG(d2) LONG ID,REG(a1) struct TagItem *TagList)
  25. {
  26.     struct TagItem *TagItem;
  27.  
  28.     if(!Handle || Handle -> Failed)
  29.         return;
  30.  
  31.     if(Type == VERTICAL_KIND || Type == HORIZONTAL_KIND || Handle -> TopGroup)
  32.     {
  33.         ObjectNode *Node;
  34.  
  35.         switch(Type)
  36.         {
  37.             case BUTTON_KIND:
  38.  
  39.                 Handle -> IDCMP |= BUTTONIDCMP;
  40.                 break;
  41.  
  42.             case CHECKBOX_KIND:
  43.  
  44.                 Handle -> IDCMP |= CHECKBOXIDCMP | IDCMP_MOUSEBUTTONS;
  45.                 break;
  46.  
  47.             case LISTVIEW_KIND:
  48.  
  49.                 Handle -> IDCMP |= LISTVIEWIDCMP;
  50.                 break;
  51.  
  52.             case MX_KIND:
  53.  
  54.                 Handle -> IDCMP |= MXIDCMP | IDCMP_MOUSEBUTTONS;
  55.                 break;
  56.  
  57.             case CYCLE_KIND:
  58.  
  59.                 Handle -> IDCMP |= CYCLEIDCMP;
  60.                 break;
  61.  
  62.             case PALETTE_KIND:
  63.  
  64.                 Handle -> IDCMP |= PALETTEIDCMP;
  65.                 break;
  66.  
  67.             case SLIDER_KIND:
  68.  
  69.                 Handle -> IDCMP |= SLIDERIDCMP;
  70.                 break;
  71.  
  72.             case SCROLLER_KIND:
  73.  
  74.                 Handle -> IDCMP |= SCROLLERIDCMP | ARROWIDCMP;
  75.                 break;
  76.  
  77.             case INTEGER_KIND:
  78.  
  79.                 Handle -> IDCMP |= STRINGIDCMP | IDCMP_GADGETDOWN | IDCMP_INTUITICKS;
  80.                 break;
  81.  
  82.             case STRING_KIND:
  83.             case FRACTION_KIND:
  84.             case PASSWORD_KIND:
  85.  
  86.                 Handle -> IDCMP |= STRINGIDCMP | IDCMP_GADGETDOWN;
  87.                 break;
  88. #ifdef DO_LEVEL_KIND
  89.             case LEVEL_KIND:
  90.  
  91.                 Handle -> IDCMP |= IDCMP_GADGETDOWN | IDCMP_MOUSEMOVE | IDCMP_GADGETUP;
  92.                 break;
  93. #endif    /* DO_LEVEL_KIND */
  94.             case END_KIND:
  95.  
  96.                 Handle -> CurrentGroup = Handle -> CurrentGroup -> Special . Group . ParentGroup;
  97.                 return;
  98.         }
  99.  
  100.         if(Node = LTP_CreateObjectNode(Handle,Type,ID,Label))
  101.         {
  102.             struct MinList    *ParentList;
  103.             LONG         FirstLabel    = -1;
  104.             LONG         LastLabel    = -1;
  105.             LONG        *LabelTable    = NULL;
  106.  
  107.             Type = Node -> Type;
  108.  
  109.             if(Type == GROUP_KIND)
  110.             {
  111.                 Node -> LabelPlace            = PLACE_IN;
  112.                 Node -> Special . Group . ParentGroup    = Handle -> CurrentGroup;
  113.  
  114.                 if(!ID)
  115.                     Node -> ID = Handle -> GroupID--;
  116.  
  117.                 if(!Handle -> TopGroup)
  118.                 {
  119.                     Handle -> TopGroup = Node;
  120.  
  121.                     ParentList = NULL;
  122.                 }
  123.                 else
  124.                     ParentList = &Handle -> CurrentGroup -> Special . Group . ObjectList;
  125.  
  126.                 Handle -> CurrentGroup = Node;
  127.  
  128.                 NewList((struct List *)&Node -> Special . Group . ObjectList);
  129.             }
  130.             else
  131.                 ParentList = &Handle -> CurrentGroup -> Special . Group . ObjectList;
  132.  
  133.             if(Label && !Node -> NoKey)
  134.             {
  135.                 ULONG Len;
  136.  
  137.                 Len = 0;
  138.  
  139.                 while(Label[Len])
  140.                 {
  141.                     if(Label[Len] == '_')
  142.                     {
  143.                         Node -> Key = ToLower(Label[Len + 1]);
  144.  
  145.                         break;
  146.                     }
  147.  
  148.                     Len++;
  149.                 }
  150.             }
  151.  
  152.             if(TagList)
  153.             {
  154.                 struct TagItem *TempList = TagList;
  155.  
  156.                 while(!Handle -> Failed && (TagItem = NextTagItem(&TempList)))
  157.                 {
  158.                     switch(TagItem -> ti_Tag)
  159.                     {
  160.                         case LA_BYTE:
  161.  
  162.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  163.                             Node -> StorageType    = STORAGE_BYTE;
  164.  
  165.                             LTP_GetStorage(Node);
  166.  
  167.                             break;
  168.  
  169.                         case LA_UBYTE:
  170.  
  171.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  172.                             Node -> StorageType    = STORAGE_UBYTE;
  173.  
  174.                             LTP_GetStorage(Node);
  175.  
  176.                             break;
  177.  
  178.                         case LA_WORD:
  179.  
  180.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  181.                             Node -> StorageType    = STORAGE_WORD;
  182.  
  183.                             LTP_GetStorage(Node);
  184.  
  185.                             break;
  186.  
  187.                         case LA_UWORD:
  188.  
  189.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  190.                             Node -> StorageType    = STORAGE_UWORD;
  191.  
  192.                             LTP_GetStorage(Node);
  193.  
  194.                             break;
  195.  
  196.                         case LA_LONG:
  197.  
  198.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  199.                             Node -> StorageType    = STORAGE_LONG;
  200.  
  201.                             LTP_GetStorage(Node);
  202.  
  203.                             break;
  204.  
  205.                         case LA_ULONG:
  206.  
  207.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  208.                             Node -> StorageType    = STORAGE_ULONG;
  209.  
  210.                             LTP_GetStorage(Node);
  211.  
  212.                             break;
  213.  
  214.                         case LA_STRPTR:
  215.  
  216.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  217.                             Node -> StorageType    = STORAGE_STRPTR;
  218.  
  219.                             LTP_GetStorage(Node);
  220.  
  221.                             break;
  222.  
  223.                         case LAXB_FullSize:
  224.  
  225.                             if(Type == XBAR_KIND || Type == YBAR_KIND)
  226.                                 Node -> Special . Bar . FullSize = TagItem -> ti_Data;
  227.  
  228.                             break;
  229.  
  230.                         case LA_LabelTable:
  231.  
  232.                             LabelTable = (LONG *)TagItem -> ti_Data;
  233.                             break;
  234.  
  235.                         case LA_FirstLabel:
  236.  
  237.                             FirstLabel = TagItem -> ti_Data;
  238.                             break;
  239.  
  240.                         case LA_LastLabel:
  241.  
  242.                             LastLabel = TagItem -> ti_Data;
  243.                             break;
  244.  
  245.                         case LA_LastGadget:
  246.  
  247.                             if(Type == INTEGER_KIND)
  248.                                 Node -> Special . Integer . LastGadget = TagItem -> ti_Data;
  249.                             else
  250.                             {
  251.                                 if(Type == FRACTION_KIND || Type == STRING_KIND || Type == PASSWORD_KIND)
  252.                                     Node -> Special . String . LastGadget = TagItem -> ti_Data;
  253.                             }
  254.  
  255.                             break;
  256.  
  257.                         case LA_LabelChars:
  258.  
  259.                             Node -> LabelChars = TagItem -> ti_Data;
  260.  
  261.                             break;
  262.  
  263.                         case LA_HistoryLines:
  264.  
  265.                             if(Type == INTEGER_KIND)
  266.                                 Node -> Special . Integer . MaxHistoryLines = TagItem -> ti_Data;
  267.                             else
  268.                             {
  269.                                 if(Type == FRACTION_KIND || Type == STRING_KIND || Type == PASSWORD_KIND)
  270.                                     Node -> Special . String . MaxHistoryLines = TagItem -> ti_Data;
  271.                             }
  272.  
  273.                             break;
  274.  
  275.                         case LA_HistoryHook:
  276.  
  277.                             if(Type == INTEGER_KIND)
  278.                                 Node -> Special . Integer . HistoryHook = (struct Hook *)TagItem -> ti_Data;
  279.                             else
  280.                             {
  281.                                 if(Type == FRACTION_KIND || Type == STRING_KIND)
  282.                                     Node -> Special . String . HistoryHook = (struct Hook *)TagItem -> ti_Data;
  283.                             }
  284.  
  285.                             break;
  286.  
  287.                         case LAIN_IncrementerHook:
  288.  
  289.                             if(Type == INTEGER_KIND)
  290.                                 Node -> Special . Integer . IncrementerHook = (struct Hook *)TagItem -> ti_Data;
  291.  
  292.                             break;
  293.  
  294.                         case LA_Min:
  295.  
  296.                             Node -> Min = TagItem -> ti_Data;
  297.  
  298.                             break;
  299.  
  300.                         case LA_Max:
  301.  
  302.                             Node -> Max = TagItem -> ti_Data;
  303.  
  304.                             break;
  305.  
  306.                         case LABX_ReserveSpace:
  307.  
  308.                             if(Type == BOX_KIND)
  309.                                 Node -> Special . Box . ReserveSpace = TagItem -> ti_Data;
  310.  
  311.                             break;
  312.  
  313.                         case LA_Chars:
  314.  
  315.                             Node -> Chars = TagItem -> ti_Data;
  316.  
  317.                             break;
  318.  
  319.                         case LA_LabelPlace:
  320.  
  321.                             Node -> LabelPlace = TagItem -> ti_Data;
  322.  
  323.                             if(Type == MX_KIND)
  324.                             {
  325.                                 if(TagItem -> ti_Data == PLACE_RIGHT)
  326.                                     Node -> LabelPlace = PLACE_RIGHT;
  327.                                 else
  328.                                     Node -> LabelPlace = PLACE_LEFT;
  329.                             }
  330.  
  331.                             break;
  332.  
  333.                         case LA_ExtraSpace:
  334.  
  335.                             Node -> ExtraSpace = (WORD)TagItem -> ti_Data;
  336.  
  337.                             if(Node -> ExtraSpace == 1)
  338.                                 Node -> ExtraSpace = 3;
  339.  
  340.                             break;
  341.  
  342.                         case LA_PageSelector:
  343.  
  344.                             Node -> PageSelector = TagItem -> ti_Data;
  345.                             break;
  346.  
  347.                         case LABT_ExtraFat:
  348.  
  349.                             if(Node -> Type == BUTTON_KIND)
  350.                                 Node -> Special . Button . ExtraFat = TagItem -> ti_Data;
  351.  
  352.                             break;
  353.  
  354.                         case LABT_Smaller:
  355.  
  356.                             if(Node -> Type == BUTTON_KIND)
  357.                                 Node -> Special . Button . Smaller = TagItem -> ti_Data;
  358.  
  359.                             break;
  360.  
  361.                         case LABT_DefaultCorrection:
  362.  
  363.                             if(Node -> Type == BUTTON_KIND)
  364.                                 Node -> Special . Button . DefaultCorrection = TagItem -> ti_Data;
  365.  
  366.                             break;
  367.  
  368.                         case LABT_Lines:
  369.  
  370.                             if(Node -> Type == BUTTON_KIND)
  371.                                 Node -> Special . Button . Lines = (STRPTR *)TagItem -> ti_Data;
  372.  
  373.                             break;
  374. #ifdef DO_PICKSHORTCUTS
  375.                         case LA_NoKey:
  376.  
  377.                             Node -> NoKey = TagItem -> ti_Data;
  378.                             break;
  379. #endif
  380.                         case LA_HighLabel:
  381.  
  382.                             Node -> HighLabel = TagItem -> ti_Data;
  383.                             break;
  384.  
  385.                         case LAPA_SmallPalette:
  386.  
  387.                             if(Type == PALETTE_KIND)
  388.                                 Node -> Special . Palette . SmallPalette = TagItem -> ti_Data;
  389.  
  390.                             break;
  391.  
  392.                         case LAPA_UsePicker:
  393.  
  394.                             if(Type == PALETTE_KIND)
  395.                                 Node -> Special . Palette . UsePicker = TagItem -> ti_Data;
  396.  
  397.                             break;
  398.  
  399.                         case LA_Lines:
  400.  
  401.                             if(Type == BOX_KIND)
  402.                             {
  403.                                 LONG Count = TagItem -> ti_Data;
  404.  
  405.                                 if(Node -> Lines != Count)
  406.                                 {
  407.                                     LTP_Free(Handle,Node -> Special . Box . Lines,sizeof(STRPTR) * Node -> Lines);
  408.  
  409.                                     Node -> Special . Box . Lines = NULL;
  410.                                 }
  411.  
  412.                                 if(!Node -> Special . Box . Lines)
  413.                                 {
  414.                                     if(Node -> Special . Box . Lines = (STRPTR *)LTP_Alloc(Handle,sizeof(STRPTR) * Count))
  415.                                     {
  416.                                         LONG i;
  417.  
  418.                                         for(i = 0 ; i < Count ; i++)
  419.                                             Node -> Special . Box . Lines[i] = "";
  420.                                     }
  421.                                     else
  422.                                         Handle -> Failed = TRUE;
  423.                                 }
  424.                             }
  425.  
  426.                             Node -> Lines = TagItem -> ti_Data;
  427.  
  428.                             break;
  429.  
  430.                         case LA_Picker:
  431.  
  432.                             if(Type == TEXT_KIND)
  433.                                 Node -> Special . Text . UsePicker = TagItem -> ti_Data;
  434.  
  435.                             if(Type == STRING_KIND)
  436.                                 Node -> Special . String . UsePicker = TagItem -> ti_Data;
  437.  
  438.                             break;
  439.  
  440.                         case LACY_AutoPageID:
  441.  
  442.                             if(Type == CYCLE_KIND)
  443.                                 Node -> Special . Cycle . AutoPageID = (LONG)TagItem -> ti_Data;
  444. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  445.                             if(Type == POPUP_KIND)
  446.                                 Node -> Special . Popup . AutoPageID = (LONG)TagItem -> ti_Data;
  447. #endif
  448. #if defined(DO_TAB_KIND) && defined(DO_BOOPSI_KIND)
  449.                             if(Type == TAB_KIND)
  450.                                 Node -> Special . Tab . AutoPageID = (LONG)TagItem -> ti_Data;
  451. #endif
  452.                             if(Type == MX_KIND)
  453.                                 Node -> Special . Radio . AutoPageID = (LONG)TagItem -> ti_Data;
  454.  
  455.                             if(Type == LISTVIEW_KIND)
  456.                                 Node -> Special . List . AutoPageID = (LONG)TagItem -> ti_Data;
  457.  
  458.                             break;
  459.  
  460.                         case LAGR_Spread:
  461.  
  462.                             if(Type == GROUP_KIND)
  463.                                 Node -> Special . Group . Spread = TagItem -> ti_Data;
  464.  
  465.                             break;
  466.  
  467.                         case LAGR_NoIndent:
  468.  
  469.                             if(Type == GROUP_KIND)
  470.                                 Node -> Special . Group . NoIndent = TagItem -> ti_Data;
  471.  
  472.                             break;
  473.  
  474.                         case LAGR_IndentX:
  475.  
  476.                             if(Type == GROUP_KIND)
  477.                                 Node -> Special . Group . IndentX = TagItem -> ti_Data;
  478.  
  479.                             break;
  480.  
  481.                         case LAGR_IndentY:
  482.  
  483.                             if(Type == GROUP_KIND)
  484.                                 Node -> Special . Group . IndentY = TagItem -> ti_Data;
  485.  
  486.                             break;
  487.  
  488.                         case LAGR_Frame:
  489.  
  490.                             if(Type == GROUP_KIND)
  491.                                 Node -> Special . Group . Frame = TagItem -> ti_Data;
  492.  
  493.                             break;
  494.  
  495.                         case LAGR_SameSize:
  496.  
  497.                             if(Type == GROUP_KIND)
  498.                                 Node -> Special . Group . SameSize = TagItem -> ti_Data;
  499.  
  500.                             break;
  501.  
  502.                         case LAGR_LastAttributes:
  503.  
  504.                             if(Type == GROUP_KIND)
  505.                                 Node -> Special . Group . LastAttributes = TagItem -> ti_Data;
  506.  
  507.                             break;
  508.  
  509.                         case LAGR_ActivePage:
  510.  
  511.                             if(Type == GROUP_KIND)
  512.                             {
  513.                                 Node -> Special . Group . ActivePage    = TagItem -> ti_Data;
  514.                                 Node -> Special . Group . Paging    = TRUE;
  515.                             }
  516.  
  517.                             break;
  518.  
  519.                         case LABT_ReturnKey:
  520.  
  521.                             if(Type == BUTTON_KIND)
  522.                                 Node -> Special . Button . ReturnKey = TagItem -> ti_Data;
  523.  
  524.                             break;
  525.  
  526.                         case LABT_EscKey:
  527.  
  528.                             if(Type == BUTTON_KIND)
  529.                                 Node -> Special . Button . EscKey = TagItem -> ti_Data;
  530.  
  531.                             break;
  532.  
  533.                         case LALV_CursorKey:
  534.  
  535.                             if(Type == LISTVIEW_KIND)
  536.                                 Node -> Special . List . CursorKey = TagItem -> ti_Data;
  537.  
  538.                             break;
  539.  
  540.                         case LALV_TextAttr:
  541.  
  542.                             if(Type == LISTVIEW_KIND)
  543.                                 Node -> Special . List . TextAttr = (struct TextAttr *)TagItem -> ti_Data;
  544.  
  545.                             break;
  546.  
  547.                         case LALV_LockSize:
  548.  
  549.                             if(Type == LISTVIEW_KIND)
  550.                                 Node -> Special . List . LockSize = TagItem -> ti_Data;
  551.  
  552.                             if(Type == TEXT_KIND)
  553.                                 Node -> Special . Text . LockSize = TagItem -> ti_Data;
  554.  
  555.                             break;
  556.  
  557.                         case LALV_MaxGrowX:
  558.  
  559.                             if(Type == LISTVIEW_KIND)
  560.                             {
  561.                                 Handle -> GrowView = Node;
  562.  
  563.                                 Node -> Special . List . MaxGrowX = TagItem -> ti_Data;
  564.                             }
  565.  
  566.                             break;
  567.  
  568.                         case LALV_MaxGrowY:
  569.  
  570.                             if(Type == LISTVIEW_KIND)
  571.                             {
  572.                                 Handle -> GrowView = Node;
  573.  
  574.                                 Node -> Special . List . MaxGrowY = TagItem -> ti_Data;
  575.                             }
  576.  
  577.                             break;
  578.  
  579.                         case LALV_ResizeX:
  580.  
  581.                             if(Type == LISTVIEW_KIND)
  582.                             {
  583.                                 Handle -> ResizeView = Node;
  584.  
  585.                                 Handle -> IDCMP |= IDCMP_SIZEVERIFY | IDCMP_NEWSIZE;
  586.  
  587.                                 Node -> Special . List . ResizeX = TagItem -> ti_Data;
  588.                             }
  589.  
  590.                             break;
  591.  
  592.                         case LALV_ResizeY:
  593.  
  594.                             if(Type == LISTVIEW_KIND)
  595.                             {
  596.                                 Handle -> ResizeView = Node;
  597.  
  598.                                 Handle -> IDCMP |= IDCMP_SIZEVERIFY | IDCMP_NEWSIZE;
  599.  
  600.                                 Node -> Special . List . ResizeY = TagItem -> ti_Data;
  601.                             }
  602.  
  603.                             break;
  604.  
  605.                         case LALV_MinChars:
  606.  
  607.                             if(Type == LISTVIEW_KIND)
  608.                                 Node -> Special . List . MinChars = TagItem -> ti_Data;
  609.  
  610.                             break;
  611.  
  612.                         case LALV_MinLines:
  613.  
  614.                             if(Type == LISTVIEW_KIND)
  615.                                 Node -> Special . List . MinLines = TagItem -> ti_Data;
  616.  
  617.                             break;
  618.  
  619.                         case LALV_FlushLabelLeft:
  620.  
  621.                             if(Type == LISTVIEW_KIND)
  622.                                 Node -> Special . List . FlushLabelLeft = TagItem -> ti_Data;
  623.  
  624.                             break;
  625.  
  626.                         case LALV_Labels:
  627.  
  628.                             if(Type == LISTVIEW_KIND)
  629.                             {
  630.                                 STRPTR *Labels = (STRPTR *)TagItem -> ti_Data;
  631.  
  632.                                 if(*Labels)
  633.                                 {
  634.                                     struct List *SomeList;
  635.  
  636.                                     if(SomeList = LTP_Alloc(Handle,sizeof(struct List)))
  637.                                     {
  638.                                         struct Node *SomeNode;
  639.  
  640.                                         NewList(SomeList);
  641.  
  642.                                         Node -> Special . List . Labels = SomeList;
  643.  
  644.                                         while(*Labels)
  645.                                         {
  646.                                             if(SomeNode = LTP_Alloc(Handle,sizeof(struct Node) + strlen(*Labels) + 1))
  647.                                             {
  648.                                                 SomeNode -> ln_Name = (STRPTR)(SomeNode + 1);
  649.  
  650.                                                 strcpy(SomeNode -> ln_Name,*Labels++);
  651.  
  652.                                                 AddTail(SomeList,SomeNode);
  653.                                             }
  654.                                         }
  655.                                     }
  656.                                 }
  657.                             }
  658.  
  659.                             break;
  660.  
  661.                         case LA_Link:
  662.  
  663.                             if(Type == LISTVIEW_KIND)
  664.                                 Node -> Special . List . LinkID = TagItem -> ti_Data;
  665.  
  666.                             if(Type == STRING_KIND || Type == FRACTION_KIND)
  667.                                 Node -> Special . String . LinkID = TagItem -> ti_Data;
  668.  
  669.                             if(Type == BOOPSI_KIND)
  670.                                 Node -> Special . BOOPSI . Link = (LONG)TagItem -> ti_Data;
  671.  
  672.                             break;
  673.  
  674. #ifdef DO_TAPEDECK_KIND
  675.                         case LATD_ButtonType:
  676.  
  677.                             if(Type == TAPEDECK_KIND)
  678.                                 Node -> Special . TapeDeck . ButtonType = TagItem -> ti_Data;
  679.  
  680.                             break;
  681.  
  682.                         case LATD_Toggle:
  683.  
  684.                             if(Type == TAPEDECK_KIND)
  685.                                 Node -> Special . TapeDeck . Toggle = TagItem -> ti_Data;
  686.  
  687.                             break;
  688.  
  689.                         case LATD_Pressed:
  690.  
  691.                             if(Type == TAPEDECK_KIND)
  692.                                 Node -> Current = TagItem -> ti_Data;
  693.  
  694.                             break;
  695.  
  696.                         case LATD_Tick:
  697.  
  698.                             if(Type == TAPEDECK_KIND)
  699.                                 Node -> Special . TapeDeck . Tick = TagItem -> ti_Data;
  700.  
  701.                             break;
  702.  
  703.                         case LATD_Smaller:
  704.  
  705.                             if(Type == TAPEDECK_KIND)
  706.                                 Node -> Special . TapeDeck . Smaller = TagItem -> ti_Data;
  707.  
  708.                             break;
  709. #endif    /* DO_TAPEDECK_KIND */
  710.  
  711. #ifdef DO_GAUGE_KIND
  712.                         case LAGA_Percent:
  713.  
  714.                             if(Type == GAUGE_KIND)
  715.                             {
  716.                                 LONG Percent = (LONG)TagItem -> ti_Data;
  717.  
  718.                                 if(Percent <= 0)
  719.                                     Node -> Current = 0;
  720.                                 else
  721.                                 {
  722.                                     if(Percent > 100)
  723.                                         Node -> Current = 100;
  724.                                     else
  725.                                         Node -> Current = Percent;
  726.                                 }
  727.                             }
  728.  
  729.                             break;
  730.  
  731.                         case LAGA_NoTicks:
  732.  
  733.                             if(Type == GAUGE_KIND)
  734.                                 Node -> Special . Gauge . NoTicks = TagItem -> ti_Data;
  735.  
  736.                             break;
  737.  
  738.                         case LAGA_Discrete:
  739.  
  740.                             if(Type == GAUGE_KIND)
  741.                                 Node -> Special . Gauge . Discrete = TagItem -> ti_Data;
  742.  
  743.                             break;
  744.  
  745.                         case LAGA_InfoLength:
  746.  
  747.                             if(Type == GAUGE_KIND)
  748.                             {
  749.                                 LONG Length = (LONG)TagItem -> ti_Data;
  750.  
  751.                                 if(Length > Node -> Special . Gauge . InfoLength)
  752.                                 {
  753.                                     STRPTR NewText;
  754.  
  755.                                     if(NewText = (STRPTR)LTP_Alloc(Handle,Length + 1))
  756.                                     {
  757.                                         if(Node -> Special . Gauge . InfoText)
  758.                                         {
  759.                                             strcpy(NewText,Node -> Special . Gauge . InfoText);
  760.  
  761.                                             LTP_Free(Handle,Node -> Special . Gauge . InfoText,Node -> Special . Gauge . InfoLength + 1);
  762.                                         }
  763.  
  764.                                         NewText[0] = 0;
  765.  
  766.                                         Node -> Special . Gauge . InfoText    = NewText;
  767.                                         Node -> Special . Gauge . InfoLength    = Length;
  768.                                     }
  769.                                     else
  770.                                         Handle -> Failed = TRUE;
  771.                                 }
  772.                             }
  773.  
  774.                             break;
  775.  
  776.                         case LAGA_InfoText:
  777.  
  778.                             if(Type == GAUGE_KIND)
  779.                             {
  780.                                 STRPTR    SomeText    = (STRPTR)TagItem -> ti_Data;
  781.                                 LONG    Len        = strlen(SomeText);
  782.  
  783.                                 if(!Node -> Special . Gauge . InfoLength)
  784.                                 {
  785.                                     if(Node -> Special . Gauge . InfoText = (STRPTR)LTP_Alloc(Handle,Len + 1))
  786.                                         Node -> Special . Gauge . InfoLength = Len;
  787.                                     else
  788.                                         Handle -> Failed = TRUE;
  789.                                 }
  790.  
  791.                                 if(Node -> Special . Gauge . InfoLength)
  792.                                 {
  793.                                     if(Len > Node -> Special . Gauge . InfoLength)
  794.                                         Len = Node -> Special . Gauge . InfoLength;
  795.  
  796.                                     CopyMem(SomeText,Node -> Special . Gauge . InfoText,Len);
  797.  
  798.                                     Node -> Special . Gauge . InfoText[Len] = 0;
  799.                                 }
  800.                             }
  801.  
  802.                             break;
  803. #endif
  804.                         case LALV_ExtraLabels:
  805.  
  806.                             if(Type == LISTVIEW_KIND)
  807.                                 Node -> Special . List . ExtraLabels = (STRPTR *)TagItem -> ti_Data;
  808.  
  809.                             break;
  810.  
  811.                         case LACY_TabKey:
  812.  
  813.                             if(Type == CYCLE_KIND)
  814.                                 Node -> Special . Cycle . TabKey = TagItem -> ti_Data;
  815. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  816.                             if(Type == POPUP_KIND)
  817.                                 Node -> Special . Popup . TabKey = TagItem -> ti_Data;
  818. #endif
  819. #if defined(DO_TAB_KIND) && defined(DO_TAB_KIND)
  820.                             if(Type == TAB_KIND)
  821.                                 Node -> Special . Tab . TabKey = TagItem -> ti_Data;
  822. #endif
  823.                             if(Type == MX_KIND)
  824.                                 Node -> Special . Radio . TabKey = TagItem -> ti_Data;
  825.  
  826.                             break;
  827.  
  828. #if defined(DO_TAB_KIND) && defined(DO_TAB_KIND)
  829.                         case LATB_FullWidth:
  830.  
  831.                             if(Type == TAB_KIND)
  832.                                 Node -> Special . Tab . FullWidth = TagItem -> ti_Data;
  833.  
  834.                             break;
  835. #endif
  836.  
  837. #ifdef DO_BOOPSI_KIND
  838.                         case LABO_FullWidth:
  839.  
  840.                             if(Type == BOOPSI_KIND)
  841.                                 Node -> Special . BOOPSI . FullWidth = (WORD)TagItem -> ti_Data;
  842.  
  843.                             break;
  844.  
  845.                         case LABO_ActivateHook:
  846.  
  847.                             if(Type == BOOPSI_KIND)
  848.                                 Node -> Special . BOOPSI . ActivateHook = (struct Hook *)TagItem -> ti_Data;
  849.  
  850.                             break;
  851.  
  852.                         case LABO_FullHeight:
  853.  
  854.                             if(Type == BOOPSI_KIND)
  855.                                 Node -> Special . BOOPSI . FullHeight = (WORD)TagItem -> ti_Data;
  856.  
  857.                             break;
  858.  
  859.                         case LABO_RelFontHeight:
  860.  
  861.                             if(Type == BOOPSI_KIND)
  862.                                 Node -> Special . BOOPSI . RelFontHeight = (WORD)TagItem -> ti_Data;
  863.  
  864.                             break;
  865.  
  866.                         case LABO_TagScreen:
  867.  
  868.                             if(Type == BOOPSI_KIND)
  869.                                 Node -> Special . BOOPSI . TagScreen = TagItem -> ti_Data;
  870.  
  871.                             break;
  872.  
  873.                         case LABO_TagCurrent:
  874.  
  875.                             if(Type == BOOPSI_KIND)
  876.                                 Node -> Special . BOOPSI . TagCurrent = TagItem -> ti_Data;
  877.  
  878.                             break;
  879.  
  880.                         case LABO_TagLink:
  881.  
  882.                             if(Type == BOOPSI_KIND)
  883.                                 Node -> Special . BOOPSI . TagLink = TagItem -> ti_Data;
  884.  
  885.                             break;
  886.  
  887.                         case LABO_ExactWidth:
  888.  
  889.                             if(Type == BOOPSI_KIND)
  890.                                 Node -> Special . BOOPSI . ExactWidth = TagItem -> ti_Data;
  891.  
  892.                             break;
  893.  
  894.                         case LABO_ExactHeight:
  895.  
  896.                             if(Type == BOOPSI_KIND)
  897.                                 Node -> Special . BOOPSI . ExactHeight = TagItem -> ti_Data;
  898.  
  899.                             break;
  900.  
  901.                         case LABO_TagTextAttr:
  902.  
  903.                             if(Type == BOOPSI_KIND)
  904.                                 Node -> Special . BOOPSI . TagTextAttr = TagItem -> ti_Data;
  905.  
  906.                             break;
  907.  
  908.                         case LABO_TagDrawInfo:
  909.  
  910.                             if(Type == BOOPSI_KIND)
  911.                                 Node -> Special . BOOPSI . TagDrawInfo = TagItem -> ti_Data;
  912.  
  913.                             break;
  914.  
  915.                         case LABO_ClassInstance:
  916.  
  917.                             if(Type == BOOPSI_KIND)
  918.                                 Node -> Special . BOOPSI . ClassInstance = (Class *)TagItem -> ti_Data;
  919.  
  920.                             break;
  921.  
  922.                         case LABO_ClassName:
  923.  
  924.                             if(Type == BOOPSI_KIND)
  925.                                 Node -> Special . BOOPSI . ClassName = (STRPTR)TagItem -> ti_Data;
  926.  
  927.                             break;
  928.  
  929.                         case LABO_ClassLibraryName:
  930.  
  931.                             if(Type == BOOPSI_KIND)
  932.                                 Node -> Special . BOOPSI . ClassLibraryName = (STRPTR)TagItem -> ti_Data;
  933.  
  934.                             break;
  935. #endif    /* DO_BOOPSI_KIND */
  936.  
  937.                         case LAFR_RefreshHook:
  938.  
  939.                             if(Type == FRAME_KIND)
  940.                                 Node -> Special . Frame . RefreshHook = (struct Hook *)TagItem -> ti_Data;
  941.  
  942.                             break;
  943.  
  944.                         case LAFR_InnerWidth:
  945.  
  946.                             if(Type == FRAME_KIND)
  947.                                 Node -> Special . Frame . InnerWidth = TagItem -> ti_Data;
  948.  
  949.                             break;
  950.  
  951.                         case LAFR_InnerHeight:
  952.  
  953.                             if(Type == FRAME_KIND)
  954.                                 Node -> Special . Frame . InnerHeight = TagItem -> ti_Data;
  955.  
  956.                             break;
  957.  
  958.                         case LA_DrawBox:
  959.  
  960.                             if(Type == FRAME_KIND)
  961.                                 Node -> Special . Frame . DrawBox = TagItem -> ti_Data;
  962.  
  963.                             if(Type == BOX_KIND)
  964.                                 Node -> Special . Box . DrawBox = TagItem -> ti_Data;
  965.  
  966.                             break;
  967.  
  968.                         case LABX_AlignText:
  969.  
  970.                             if(Type == BOX_KIND)
  971.                                 Node -> Special . Box . AlignText = TagItem -> ti_Data;
  972.  
  973.                             break;
  974.  
  975.                         case LABX_Labels:
  976.  
  977.                             if(Type == BOX_KIND)
  978.                             {
  979.                                 STRPTR    *Labels = (STRPTR *)TagItem -> ti_Data;
  980.                                 LONG     Count    = 0;
  981.  
  982.                                 while(Labels[Count])
  983.                                     Count++;
  984.  
  985.                                 if(Node -> Lines != Count)
  986.                                 {
  987.                                     LTP_Free(Handle,Node -> Special . Box . Lines,sizeof(STRPTR) * Node -> Lines);
  988.  
  989.                                     Node -> Special . Box . Lines = NULL;
  990.                                 }
  991.  
  992.                                 if(Count)
  993.                                 {
  994.                                     if(!Node -> Special . Box . Lines)
  995.                                     {
  996.                                         if(Node -> Special . Box . Lines = LTP_Alloc(Handle,sizeof(STRPTR) * Count))
  997.                                         {
  998.                                             LONG i;
  999.  
  1000.                                             for(i = 0 ; i < Count ; i++)
  1001.                                                 Node -> Special . Box . Lines[i] = "";
  1002.                                         }
  1003.                                     }
  1004.                                 }
  1005.  
  1006.                                 Node -> Lines = Count;
  1007.  
  1008.                                 Node -> Special . Box . Labels = Labels;
  1009.                             }
  1010.  
  1011.                             break;
  1012.  
  1013.                         case LABX_Lines:
  1014.  
  1015.                             if(Type == BOX_KIND)
  1016.                             {
  1017.                                 STRPTR    *Lines = (STRPTR *)TagItem -> ti_Data;
  1018.                                 LONG     Count = 0;
  1019.  
  1020.                                 while(Lines[Count])
  1021.                                     Count++;
  1022.  
  1023.                                 if(Node -> Lines && Count > Node -> Lines)
  1024.                                     Count = Node -> Lines;
  1025.  
  1026.                                 if(Count)
  1027.                                 {
  1028.                                     if(!Node -> Special . Box . Lines)
  1029.                                         Node -> Special . Box . Lines = LTP_Alloc(Handle,sizeof(STRPTR) * Count);
  1030.  
  1031.                                     if(Node -> Special . Box . Lines)
  1032.                                     {
  1033.                                         LONG i;
  1034.  
  1035.                                         for(i = 0 ; i < Count ; i++)
  1036.                                             Node -> Special . Box . Lines[i] = Lines[i];
  1037.                                     }
  1038.                                 }
  1039.  
  1040.                                 Node -> Lines = Count;
  1041.                             }
  1042.  
  1043.                             break;
  1044.  
  1045.                         case GA_Disabled:
  1046.  
  1047.                             Node -> Disabled = TagItem -> ti_Data;
  1048.                             break;
  1049.  
  1050.                         case GTCB_Checked:
  1051.  
  1052.                             if(Type == CHECKBOX_KIND)
  1053.                                 Node -> Current = TagItem -> ti_Data;
  1054.  
  1055.                             break;
  1056.  
  1057.                         case GTLV_Labels:
  1058.  
  1059.                             if(Type == LISTVIEW_KIND)
  1060.                             {
  1061.                                 if(TagItem -> ti_Data)
  1062.                                     Node -> Special . List . Labels = (struct List *)TagItem -> ti_Data;
  1063.                                 else
  1064.                                     Node -> Special . List . Labels = (struct List *)<P_EmptyList;
  1065.                             }
  1066.  
  1067.                             break;
  1068.  
  1069.                         case GTLV_ReadOnly:
  1070.  
  1071.                             if(Type == LISTVIEW_KIND)
  1072.                                 Node -> Special . List . ReadOnly = TagItem -> ti_Data;
  1073.  
  1074.                             break;
  1075.  
  1076.                         case GTLV_MakeVisible:
  1077.                         case GTLV_Selected:
  1078.  
  1079.                             if(Type == LISTVIEW_KIND)
  1080.                                 Node -> Current = (LONG)TagItem -> ti_Data;
  1081.  
  1082.                             break;
  1083.  
  1084.                         case GTLV_CallBack:
  1085.  
  1086.                             if(Type == LISTVIEW_KIND)
  1087.                                 Node -> Special . List . CallBack = (struct Hook *)TagItem -> ti_Data;
  1088.  
  1089.                             break;
  1090.  
  1091.                         case GTLV_MaxPen:
  1092.  
  1093.                             if(Type == LISTVIEW_KIND)
  1094.                                 Node -> Special . List . MaxPen = TagItem -> ti_Data;
  1095.  
  1096.                             break;
  1097.  
  1098.                         case GTMX_Labels:
  1099.  
  1100.                             if(Type == MX_KIND)
  1101.                                 Node -> Special . Radio . Choices = (STRPTR *)TagItem -> ti_Data;
  1102.  
  1103.                             break;
  1104.  
  1105.                         case GTMX_Active:
  1106.  
  1107.                             if(Type == MX_KIND)
  1108.                                 Node -> Current = TagItem -> ti_Data;
  1109.  
  1110.                             break;
  1111.  
  1112.                         case GTMX_TitlePlace:
  1113.  
  1114.                             if(Type == MX_KIND && Label)
  1115.                             {
  1116.                                 if(TagItem -> ti_Data == PLACE_RIGHT)
  1117.                                     Node -> Special . Radio . TitlePlace = PLACETEXT_RIGHT;
  1118.                                 else
  1119.                                     Node -> Special . Radio . TitlePlace = PLACETEXT_LEFT;
  1120.                             }
  1121.  
  1122.                             break;
  1123.  
  1124.                         case GTTX_Text:
  1125.  
  1126.                             if(Type == TEXT_KIND)
  1127.                                 Node -> Special . Text . Text = (STRPTR)TagItem -> ti_Data;
  1128.  
  1129.                             break;
  1130.  
  1131.                         case GTTX_CopyText:
  1132.  
  1133.                             if(Type == TEXT_KIND)
  1134.                                 Node -> Special . Text . CopyText = TagItem -> ti_Data;
  1135.  
  1136.                             break;
  1137.  
  1138.                         case GTTX_Border:
  1139.  
  1140.                             if(Type == TEXT_KIND)
  1141.                                 Node -> Special . Text . Border = TagItem -> ti_Data;
  1142.  
  1143.                             break;
  1144.  
  1145.                         case GTNM_Number:
  1146.  
  1147.                             if(Type == NUMBER_KIND)
  1148.                                 Node -> Special . Number . Number = TagItem -> ti_Data;
  1149.  
  1150.                             break;
  1151.  
  1152.                         case GTNM_Format:
  1153.  
  1154.                             if(Type == NUMBER_KIND)
  1155.                                 Node -> Special . Number . Format = (STRPTR)TagItem -> ti_Data;
  1156.  
  1157.                             break;
  1158.  
  1159.                         case GTNM_Border:
  1160.  
  1161.                             if(Type == NUMBER_KIND)
  1162.                                 Node -> Special . Number . Border = TagItem -> ti_Data;
  1163.  
  1164.                             break;
  1165.  
  1166.                         case GTTX_Justification:
  1167.  
  1168.                             if(Type == NUMBER_KIND)
  1169.                                 Node -> Special . Number . Justification = TagItem -> ti_Data;
  1170.  
  1171.                             if(Type == TEXT_KIND)
  1172.                                 Node -> Special . Text . Justification = TagItem -> ti_Data;
  1173.  
  1174.                             break;
  1175.  
  1176.                         case GTCY_Labels:
  1177.  
  1178.                             if(Type == CYCLE_KIND)
  1179.                                 Node -> Special . Cycle . Choices = (STRPTR *)TagItem -> ti_Data;
  1180. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  1181.                             if(Type == POPUP_KIND)
  1182.                                 Node -> Special . Popup . Choices = (STRPTR *)TagItem -> ti_Data;
  1183. #endif
  1184. #if defined(DO_TAB_KIND) && defined(DO_BOOPSI_KIND)
  1185.                             if(Type == TAB_KIND)
  1186.                                 Node -> Special . Tab . Choices = (STRPTR *)TagItem -> ti_Data;
  1187. #endif
  1188.                             break;
  1189.  
  1190.                         case GTCY_Active:
  1191.  
  1192.                             if(Type == CYCLE_KIND)
  1193.                                 Node -> Current = TagItem -> ti_Data;
  1194. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  1195.                             if(Type == POPUP_KIND)
  1196.                                 Node -> Current = TagItem -> ti_Data;
  1197. #endif
  1198. #if defined(DO_TAB_KIND) && defined(DO_BOOPSI_KIND)
  1199.                             if(Type == TAB_KIND)
  1200.                                 Node -> Current = TagItem -> ti_Data;
  1201. #endif
  1202.                             break;
  1203.  
  1204.                         case GTPA_Depth:
  1205.  
  1206.                             if(Type == PALETTE_KIND)
  1207.                             {
  1208.                                 Node -> Special . Palette . Depth = TagItem -> ti_Data;
  1209.  
  1210.                                 if(Handle -> MaxPen < (1L << Node -> Special . Palette . Depth) - 1)
  1211.                                     Handle -> MaxPen = (1L << Node -> Special . Palette . Depth) - 1;
  1212.                             }
  1213.  
  1214.                             break;
  1215.  
  1216.                         case GTPA_Color:
  1217.  
  1218.                             if(Type == PALETTE_KIND)
  1219.                                 Node -> Current = TagItem -> ti_Data;
  1220.  
  1221.                             break;
  1222.  
  1223.                         case GTPA_ColorOffset:
  1224.  
  1225.                             if(Type == PALETTE_KIND)
  1226.                                 Node -> Min = TagItem -> ti_Data;
  1227.  
  1228.                             break;
  1229.  
  1230.                         case GTPA_NumColors:
  1231.  
  1232.                             if(Type == PALETTE_KIND)
  1233.                             {
  1234.                                 Node -> Special . Palette . NumColours = TagItem -> ti_Data;
  1235.  
  1236.                                 if(Node -> Special . Palette . ColourTable)
  1237.                                 {
  1238.                                     LONG i;
  1239.  
  1240.                                     for(i = 0 ; i < Node -> Special . Palette . NumColours ; i++)
  1241.                                     {
  1242.                                         if(Node -> Special . Palette . ColourTable[i] > Handle -> MaxPen)
  1243.                                             Handle -> MaxPen = Node -> Special . Palette . ColourTable[i];
  1244.                                     }
  1245.                                 }
  1246.                             }
  1247.  
  1248.                             break;
  1249.  
  1250.                         case GTPA_ColorTable:
  1251.  
  1252.                             if(Type == PALETTE_KIND)
  1253.                             {
  1254.                                 Node -> Special . Palette . ColourTable = (UBYTE *)TagItem -> ti_Data;
  1255.  
  1256.                                 if(Node -> Special . Palette . NumColours)
  1257.                                 {
  1258.                                     LONG i;
  1259.  
  1260.                                     for(i = 0 ; i < Node -> Special . Palette . NumColours ; i++)
  1261.                                     {
  1262.                                         if(Node -> Special . Palette . ColourTable[i] > Handle -> MaxPen)
  1263.                                             Handle -> MaxPen = Node -> Special . Palette . ColourTable[i];
  1264.                                     }
  1265.                                 }
  1266.                             }
  1267.  
  1268.                             break;
  1269.  
  1270.                         case GTSC_Top:
  1271.  
  1272.                             if(Type == SCROLLER_KIND)
  1273.                                 Node -> Current = TagItem -> ti_Data;
  1274.  
  1275.                             break;
  1276.  
  1277.                         case GTSC_Total:
  1278.  
  1279.                             if(Type == SCROLLER_KIND)
  1280.                                 Node -> Max = TagItem -> ti_Data;
  1281.  
  1282.                             break;
  1283.  
  1284.                         case GTSC_Visible:
  1285.  
  1286.                             if(Type == SCROLLER_KIND)
  1287.                                 Node -> Special . Scroller . Visible = TagItem -> ti_Data;
  1288.  
  1289.                             break;
  1290.  
  1291.                         case GTSC_Arrows:
  1292.  
  1293.                             if(Type == SCROLLER_KIND)
  1294.                                 Node -> Special . Scroller . Arrows = (TagItem -> ti_Data != 0);
  1295.  
  1296.                             break;
  1297.  
  1298.                         case LASC_Thin:
  1299.  
  1300.                             if(Type == SCROLLER_KIND)
  1301.                                 Node -> Special . Scroller . Thin = TagItem -> ti_Data;
  1302.  
  1303.                             break;
  1304.  
  1305.                         case PGA_Freedom:
  1306.  
  1307.                             if(Type == SCROLLER_KIND)
  1308.                                 Node -> Special . Scroller . Vertical = (TagItem -> ti_Data == LORIENT_VERT);
  1309.  
  1310.                             break;
  1311.  
  1312.                         case GTSL_Min:
  1313.  
  1314. #ifdef DO_LEVEL_KIND
  1315.                             if(Type == LEVEL_KIND)
  1316.                                 Node -> Special . Level . Min = (LONG)TagItem -> ti_Data;
  1317. #endif    /* DO_LEVEL_KIND */
  1318.                             if(Type == SLIDER_KIND)
  1319.                                 Node -> Min = TagItem -> ti_Data;
  1320.  
  1321.                             break;
  1322.  
  1323.                         case GTSL_Max:
  1324.  
  1325. #ifdef DO_LEVEL_KIND
  1326.                             if(Type == LEVEL_KIND)
  1327.                                 Node -> Special . Level . Max = (LONG)TagItem -> ti_Data;
  1328. #endif    /* DO_LEVEL_KIND */
  1329.                             if(Type == SLIDER_KIND)
  1330.                                 Node -> Max = TagItem -> ti_Data;
  1331.  
  1332.                             break;
  1333.  
  1334.                         case GTSL_Level:
  1335.  
  1336. #ifdef DO_LEVEL_KIND
  1337.                             if(Type == LEVEL_KIND)
  1338.                                 Node -> Special . Level . Level = (LONG)TagItem -> ti_Data;
  1339. #endif    /* DO_LEVEL_KIND */
  1340.                             if(Type == SLIDER_KIND)
  1341.                                 Node -> Current = TagItem -> ti_Data;
  1342.  
  1343.                             break;
  1344.  
  1345.                         case GTSL_LevelFormat:
  1346.  
  1347. #ifdef DO_LEVEL_KIND
  1348.                             if(Type == LEVEL_KIND)
  1349.                                 Node -> Special . Level . LevelFormat = (STRPTR)TagItem -> ti_Data;
  1350. #endif    /* DO_LEVEL_KIND */
  1351.                             if(Type == SLIDER_KIND)
  1352.                                 Node -> Special . Slider . LevelFormat = (STRPTR)TagItem -> ti_Data;
  1353.  
  1354.                             break;
  1355.  
  1356.                         case GTSL_LevelPlace:
  1357.  
  1358. #ifdef DO_LEVEL_KIND
  1359.                             if(Type == LEVEL_KIND)
  1360.                             {
  1361.                                 if(TagItem -> ti_Data == PLACE_RIGHT)
  1362.                                     Node -> Special . Level . LevelPlace = PLACETEXT_RIGHT;
  1363.                                 else
  1364.                                     Node -> Special . Level . LevelPlace = PLACETEXT_LEFT;
  1365.                             }
  1366. #endif    /* DO_LEVEL_KIND */
  1367.                             if(Type == SLIDER_KIND)
  1368.                             {
  1369.                                 if(TagItem -> ti_Data == PLACE_RIGHT)
  1370.                                     Node -> Special . Slider . LevelPlace = PLACETEXT_RIGHT;
  1371.                                 else
  1372.                                     Node -> Special . Slider . LevelPlace = PLACETEXT_LEFT;
  1373.                             }
  1374.  
  1375.                             break;
  1376.  
  1377.                         case GTSL_DispFunc:
  1378.  
  1379. #pragma msg 225 ignore push
  1380.  
  1381. #ifdef DO_LEVEL_KIND
  1382.                             if(Type == LEVEL_KIND)
  1383.                                 Node -> Special . Level . DispFunc = (DISPFUNC)TagItem -> ti_Data;
  1384. #endif    /* DO_LEVEL_KIND */
  1385.                             if(Type == SLIDER_KIND)
  1386.                                 Node -> Special . Slider . DispFunc = (DISPFUNC)TagItem -> ti_Data;
  1387.  
  1388.                             break;
  1389.  
  1390. #pragma msg 225 pop
  1391.  
  1392.                         case LASL_FullCheck:
  1393.  
  1394.                             if(Type == SLIDER_KIND)
  1395.                                 Node -> Special . Slider . FullLevelCheck = TagItem -> ti_Data;
  1396.  
  1397. #ifdef DO_LEVEL_KIND
  1398.                             if(Type == LEVEL_KIND)
  1399.                                 Node -> Special . Level . FullLevelCheck = TagItem -> ti_Data;
  1400. #endif    /* DO_LEVEL_KIND */
  1401.                             break;
  1402.  
  1403.                         case GTST_String:
  1404.  
  1405.                             if(Type == STRING_KIND || Type == PASSWORD_KIND)
  1406.                                 Node -> Special . String . String = (STRPTR)TagItem -> ti_Data;
  1407.  
  1408.                             break;
  1409.  
  1410.                         case LAST_Activate:
  1411.  
  1412.                             if(Type == STRING_KIND || Type == PASSWORD_KIND || Type == FRACTION_KIND)
  1413.                                 Node -> Special . String . Activate = TagItem -> ti_Data;
  1414.  
  1415.                             if(Type == INTEGER_KIND)
  1416.                                 Node -> Special . Integer . Activate = TagItem -> ti_Data;
  1417.  
  1418.                             break;
  1419.  
  1420.                         case GTST_MaxChars:
  1421.  
  1422.                             if(Type == STRING_KIND || Type == PASSWORD_KIND)
  1423.                                 Node -> Special . String . MaxChars = TagItem -> ti_Data;
  1424.  
  1425.                             break;
  1426.  
  1427.                         case GTST_EditHook:
  1428.  
  1429.                             if(Type == STRING_KIND)
  1430.                                 Node -> Special . String . EditHook = (struct Hook *)TagItem -> ti_Data;
  1431.                             else
  1432.                             {
  1433.                                 if(Type == INTEGER_KIND)
  1434.                                 {
  1435.                                     if(Node -> Special . Integer . EditHook = (struct Hook *)TagItem -> ti_Data)
  1436.                                         Node -> Special . Integer . CustomHook = TRUE;
  1437.                                 }
  1438.                             }
  1439.  
  1440.                             break;
  1441.  
  1442.                         case STRINGA_Justification:
  1443.  
  1444.                             if(Type == STRING_KIND || Type == FRACTION_KIND || Type == PASSWORD_KIND)
  1445.                                 Node -> Special . String . Justification = TagItem -> ti_Data;
  1446.                             else
  1447.                             {
  1448.                                 if(Type == INTEGER_KIND)
  1449.                                     Node -> Special . Integer . Justification = TagItem -> ti_Data;
  1450.                             }
  1451.  
  1452.                             break;
  1453. #ifdef DO_FRACTION_KIND
  1454.                         case LAFC_MaxChars:
  1455.  
  1456.                             if(Type == FRACTION_KIND)
  1457.                                 Node -> Special . String . MaxChars = TagItem -> ti_Data;
  1458.  
  1459.                             break;
  1460.  
  1461.                         case LAFC_Number:
  1462.  
  1463.                             if(Type == FRACTION_KIND)
  1464.                                 Node -> Current = TagItem -> ti_Data;
  1465.  
  1466.                             break;
  1467. #endif
  1468.                         case LAIN_UseIncrementers:
  1469.  
  1470.                             if(Type == INTEGER_KIND)
  1471.                             {
  1472.                                 if(Node -> Special . Integer . UseIncrementers = TagItem -> ti_Data)
  1473.                                     Handle -> IDCMP |= IDCMP_INTUITICKS;
  1474.                             }
  1475.  
  1476.                             break;
  1477.  
  1478.                         case GTIN_Number:
  1479.  
  1480.                             if(Type == INTEGER_KIND)
  1481.                                 Node -> Special . Integer . Number = TagItem -> ti_Data;
  1482.  
  1483.                             break;
  1484.  
  1485.                         case GTIN_MaxChars:
  1486.  
  1487.                             if(Type == INTEGER_KIND)
  1488.                                 Node -> Special . Integer . MaxChars = TagItem -> ti_Data;
  1489.  
  1490.                             break;
  1491.                     }
  1492.                 }
  1493.             }
  1494.  
  1495.             if(Handle -> Failed)
  1496.                 return;
  1497.  
  1498.             if((Type == FRACTION_KIND || Type == STRING_KIND || Type == INTEGER_KIND) && Node -> Special . String . MaxHistoryLines)
  1499.             {
  1500.                 if(!Node -> Special . Integer . HistoryHook)
  1501.                 {
  1502.                     struct Hook *Hook;
  1503.  
  1504.                     if(Hook = (struct Hook *)LTP_Alloc(Handle,sizeof(struct Hook) + sizeof(struct MinList)))
  1505.                     {
  1506.                         struct MinList *List;
  1507.  
  1508.                         List = Hook -> h_Data = (APTR)(Hook + 1);
  1509.  
  1510.                         NewList((struct List *)List);
  1511.  
  1512.                         Hook -> h_Entry = (HOOKFUNC)LTP_DefaultHistoryHook;
  1513.  
  1514.                         Node -> Special . Integer . HistoryHook = Hook;
  1515.                     }
  1516.                 }
  1517.  
  1518.                 if(Node -> Special . Integer . HistoryHook)
  1519.                 {
  1520.                     struct Node    *TextNode;
  1521.                     struct MinList    *List = (struct List *)Node -> Special . Integer . HistoryHook -> h_Data;
  1522.  
  1523.                     Node -> Special . Integer . LayoutHandle    = Handle;
  1524.                     Node -> Special . Integer . NumHistoryLines    = 0;
  1525.  
  1526.                     TextNode = (struct Node *)List -> mlh_Head;
  1527.  
  1528.                     while(TextNode -> ln_Succ)
  1529.                     {
  1530.                         Node -> Special . Integer . NumHistoryLines++;
  1531.  
  1532.                         TextNode = TextNode -> ln_Succ;
  1533.                     }
  1534.                 }
  1535.             }
  1536.  
  1537. #ifdef DO_BOOPSI_KIND
  1538. #ifdef DO_TAB_KIND
  1539.             if(Type == TAB_KIND)
  1540.                 Node -> Special . Tab . Parent = Handle -> CurrentGroup;
  1541. #endif
  1542.             if(Type == BOOPSI_KIND)
  1543.             {
  1544.                 Node -> Special . BOOPSI . Parent = Handle -> CurrentGroup;
  1545.  
  1546.                 if(Node -> Special . BOOPSI . ClassTags = CloneTagItems(TagList))
  1547.                 {
  1548.                     STATIC ULONG Exclude[] =
  1549.                     {
  1550.                         LA_Chars,
  1551.                         LA_Lines,
  1552.                         LABO_TagCurrent,
  1553.                         LABO_TagTextAttr,
  1554.                         LABO_TagDrawInfo,
  1555.                         LABO_ClassInstance,
  1556.                         LABO_ClassName,
  1557.                         LABO_ClassLibraryName,
  1558.                         LABO_ExactWidth,
  1559.                         LABO_ExactHeight,
  1560.  
  1561.                         TAG_DONE
  1562.                     };
  1563.  
  1564.                     FilterTagItems(Node -> Special . BOOPSI . ClassTags,(Tag *)Exclude,TAGFILTER_NOT);
  1565.                 }
  1566.                 else
  1567.                     Handle -> Failed = TRUE;
  1568.             }
  1569. #endif    /* DO_BOOPSI_KIND */
  1570.  
  1571.             if(Type == TEXT_KIND && Node -> Special . Text . CopyText && Node -> Special . Text . Text)
  1572.             {
  1573.                 LONG    len;
  1574.                 STRPTR    text;
  1575.  
  1576.                 len = strlen(Node -> Special . Text . Text);
  1577.  
  1578.                 if(text = LTP_Alloc(Handle,len + 1))
  1579.                 {
  1580.                     strcpy(text,Node -> Special . Text . Text);
  1581.  
  1582.                     Node -> Special . Text . Text = text;
  1583.                 }
  1584.             }
  1585.  
  1586.             if((FirstLabel != -1 && LastLabel != -1) || LabelTable)
  1587.             {
  1588.                 if(Type == MX_KIND || Type == CYCLE_KIND || Type == POPUP_KIND || Type == TAB_KIND || Type == LISTVIEW_KIND || Type == BOX_KIND || Type == BUTTON_KIND)
  1589.                 {
  1590.                     if(!Handle -> LocaleHook)
  1591.                         Handle -> Failed = TRUE;
  1592.                     else
  1593.                     {
  1594.                         if(Type == LISTVIEW_KIND)
  1595.                         {
  1596.                             struct List *SomeList;
  1597.  
  1598.                             if(SomeList = (struct List *)LTP_Alloc(Handle,sizeof(struct List)))
  1599.                             {
  1600.                                 struct Node    *SomeNode;
  1601.                                 LONG         Count = (LastLabel - FirstLabel + 1),i;
  1602.  
  1603.                                 NewList(SomeList);
  1604.  
  1605.                                 Node -> Special . List . Labels = SomeList;
  1606.  
  1607.                                 if(LabelTable)
  1608.                                 {
  1609.                                     while(*LabelTable != -1)
  1610.                                     {
  1611.                                         if(SomeNode = LTP_Alloc(Handle,sizeof(struct Node)))
  1612.                                         {
  1613.                                             SomeNode -> ln_Name = (STRPTR)CallHookPkt(Handle -> LocaleHook,Handle,(APTR)(*LabelTable++));
  1614.  
  1615.                                             AddTail(SomeList,SomeNode);
  1616.                                         }
  1617.                                     }
  1618.                                 }
  1619.                                 else
  1620.                                 {
  1621.                                     for(i = 0 ; i < Count ; i++)
  1622.                                     {
  1623.                                         if(SomeNode = LTP_Alloc(Handle,sizeof(struct Node)))
  1624.                                         {
  1625.                                             SomeNode -> ln_Name = (STRPTR)CallHookPkt(Handle -> LocaleHook,Handle,(APTR)(FirstLabel + i));
  1626.  
  1627.                                             AddTail(SomeList,SomeNode);
  1628.                                         }
  1629.                                     }
  1630.                                 }
  1631.                             }
  1632.                         }
  1633.                         else
  1634.                         {
  1635.                             STRPTR    *Labels;
  1636.                             LONG     Count = (LastLabel - FirstLabel + 1),i;
  1637.  
  1638.                             if(LabelTable)
  1639.                             {
  1640.                                 register LONG *Index = LabelTable;
  1641.  
  1642.                                 for(Count = 0 ; *Index != -1 ; Count++, Index++);
  1643.                             }
  1644.  
  1645.                             if(Labels = LTP_Alloc(Handle,sizeof(STRPTR) * (Count + 1)))
  1646.                             {
  1647.                                 if(LabelTable)
  1648.                                 {
  1649.                                     for(i = 0 ; i < Count ; i++)
  1650.                                         Labels[i] = (STRPTR)CallHookPkt(Handle -> LocaleHook,Handle,(APTR)(*LabelTable++));
  1651.                                 }
  1652.                                 else
  1653.                                 {
  1654.                                     for(i = 0 ; i < Count ; i++)
  1655.                                         Labels[i] = (STRPTR)CallHookPkt(Handle -> LocaleHook,Handle,(APTR)(FirstLabel + i));
  1656.                                 }
  1657.  
  1658.                                 Labels[i] = NULL;
  1659.  
  1660.                                 if(Type == MX_KIND)
  1661.                                     Node -> Special . Radio . Choices = Labels;
  1662.                                 else
  1663.                                 {
  1664.                                     if(Type == CYCLE_KIND)
  1665.                                         Node -> Special . Cycle . Choices = Labels;
  1666.                                     else
  1667.                                     {
  1668. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  1669.                                         if(Type == POPUP_KIND)
  1670.                                             Node -> Special . Popup . Choices = Labels;
  1671. #endif
  1672. #if defined(DO_TAB_KIND) && defined(DO_BOOPSI_KIND)
  1673.                                         if(Type == TAB_KIND)
  1674.                                             Node -> Special . Tab . Choices = Labels;
  1675. #endif
  1676.                                         if(Type == BOX_KIND)
  1677.                                         {
  1678.                                             if(!Node -> Special . Box . Lines)
  1679.                                             {
  1680.                                                 if(Node -> Special . Box . Lines = LTP_Alloc(Handle,sizeof(STRPTR) * Count))
  1681.                                                 {
  1682.                                                     LONG i;
  1683.  
  1684.                                                     for(i = 0 ; i < Count ; i++)
  1685.                                                         Node -> Special . Box . Lines[i] = "";
  1686.                                                 }
  1687.                                             }
  1688.  
  1689.                                             Node -> Lines = Count;
  1690.  
  1691.                                             Node -> Special . Box . Labels = Labels;
  1692.                                         }
  1693.                                         else
  1694.                                         {
  1695.                                             if(Type == BUTTON_KIND)
  1696.                                                 Node -> Special . Button . Lines = Labels;
  1697.                                         }
  1698.                                     }
  1699.                                 }
  1700.                             }
  1701.                         }
  1702.                     }
  1703.                 }
  1704.             }
  1705.  
  1706.             if(Type == BUTTON_KIND && Node -> Special . Button . Lines && !Node -> NoKey && !Node -> Key)
  1707.             {
  1708.                 ULONG    Len;
  1709.                 STRPTR    Label,*Index = Node -> Special . Button . Lines;
  1710.                 BOOL    GotIt = FALSE;
  1711.  
  1712.                 while(*Index && !GotIt)
  1713.                 {
  1714.                     Label = *Index++;
  1715.  
  1716.                     Len = 0;
  1717.  
  1718.                     while(Label[Len])
  1719.                     {
  1720.                         if(Label[Len] == '_')
  1721.                         {
  1722.                             Node -> Key = ToLower(Label[Len + 1]);
  1723.  
  1724.                             GotIt = TRUE;
  1725.  
  1726.                             break;
  1727.                         }
  1728.  
  1729.                         Len++;
  1730.                     }
  1731.                 }
  1732.             }
  1733.  
  1734.             if(Type == BOX_KIND && Node -> Special . Box . ReserveSpace)
  1735.             {
  1736.                 LONG    Size;
  1737.                 STRPTR    Buffer;
  1738.  
  1739.                 if(!Node -> Special . Box . Lines)
  1740.                 {
  1741.                     if(Node -> Special . Box . Lines = LTP_Alloc(Handle,sizeof(STRPTR) * Node -> Lines))
  1742.                     {
  1743.                         LONG i;
  1744.  
  1745.                         for(i = 0 ; i < Node -> Lines ; i++)
  1746.                             Node -> Special . Box . Lines[i] = "";
  1747.                     }
  1748.                 }
  1749.  
  1750.                 if(!Node -> Chars)
  1751.                     Size = 10;
  1752.                 else
  1753.                     Size = Node -> Chars;
  1754.  
  1755.                 Node -> Special . Box . MaxSize = Size;
  1756.  
  1757.                 if(Buffer = (STRPTR)LTP_Alloc(Handle,(Size + 1) * Node -> Lines))
  1758.                 {
  1759.                     LONG i,Len;
  1760.  
  1761.                     for(i = 0 ; i < Node -> Lines ; i++)
  1762.                     {
  1763.                         if(Node -> Special . Box . Lines[i])
  1764.                         {
  1765.                             Len = strlen(Node -> Special . Box . Lines[i]);
  1766.  
  1767.                             if(Len > Size)
  1768.                                 Len = Size;
  1769.  
  1770.                             CopyMem(Node -> Special . Box . Lines[i],Buffer,Len);
  1771.  
  1772.                             Buffer[Len] = 0;
  1773.                         }
  1774.                         else
  1775.                             Buffer[0] = 0;
  1776.  
  1777.                         Node -> Special . Box . Lines[i] = Buffer;
  1778.  
  1779.                         Buffer += Size + 1;
  1780.                     }
  1781.                 }
  1782.             }
  1783.  
  1784.             if(Handle -> Failed)
  1785.                 return;
  1786.  
  1787.             if(ParentList)
  1788.             {
  1789. #ifdef DO_PASSWORD_KIND
  1790.                 if(Type == PASSWORD_KIND)
  1791.                 {
  1792.                     STRPTR Buffer;
  1793.  
  1794.                     if(!(Buffer = LTP_Alloc(Handle,2 * (Node -> Special . String . MaxChars + 1))))
  1795.                         return;
  1796.  
  1797.                     Node -> Special . String . RealString    = Buffer;
  1798.                     Node -> Special . String . Original    = Buffer + Node -> Special . String . MaxChars + 1;
  1799.  
  1800.                     if(Node -> Special . String . String)
  1801.                     {
  1802.                         strcpy(Node -> Special . String . RealString,    Node -> Special . String . String);
  1803.                         strcpy(Node -> Special . String . Original,    Node -> Special . String . String);
  1804.                     }
  1805.                 }
  1806. #endif
  1807.                 AddTail((struct List *)ParentList,(struct Node *)Node);
  1808.  
  1809.                 if(Type == XBAR_KIND || Type == YBAR_KIND)
  1810.                     Node -> Special . Bar . Parent = Handle -> CurrentGroup;
  1811.             }
  1812.         }
  1813.     }
  1814. }
  1815.  
  1816.  
  1817. /*****************************************************************************/
  1818.  
  1819.  
  1820. VOID __stdargs
  1821. LT_AddL(LayoutHandle *handle,UBYTE type,ULONG labelID,LONG id,...)
  1822. {
  1823.     if(handle)
  1824.     {
  1825.         struct TagItem    *tagList;
  1826.         va_list      varArg;
  1827.  
  1828.         va_start(varArg,id);
  1829.  
  1830.         tagList = (struct TagItem *)varArg;
  1831.  
  1832.         if(handle -> LocaleHook)
  1833.         {
  1834.             STRPTR label;
  1835.  
  1836.             label = (STRPTR)CallHookPkt(handle -> LocaleHook,handle,(APTR)labelID);
  1837.  
  1838.             LT_AddA(handle,type,label,id,tagList);
  1839.         }
  1840.         else
  1841.             handle -> Failed = TRUE;
  1842.  
  1843.         va_end(varArgs);
  1844.     }
  1845. }
  1846.  
  1847.  
  1848. /*****************************************************************************/
  1849.  
  1850.  
  1851. VOID __stdargs
  1852. LT_New(LayoutHandle *handle,...)
  1853. {
  1854.     va_list VarArgs;
  1855.  
  1856.     va_start(VarArgs,handle);
  1857.     LT_NewA(handle,(struct TagItem *)VarArgs);
  1858.     va_end(VarArgs);
  1859. }
  1860.  
  1861.  
  1862. /*****************************************************************************/
  1863.  
  1864.  
  1865. VOID LIBENT
  1866. LT_NewA(REG(a0) LayoutHandle *handle,REG(a1) struct TagItem *tagList)
  1867. {
  1868.     if(handle)
  1869.     {
  1870.         WORD         type    = -1;    // NOTEZ-BIEN: All object type values must be >= GENERIC_KIND!
  1871.         STRPTR         label    = NULL;
  1872.         LONG         id    = 0;
  1873.         struct TagItem    *List    = tagList,
  1874.                 *Entry;
  1875.  
  1876.         while(Entry = NextTagItem(&List))
  1877.         {
  1878.             switch(Entry -> ti_Tag)
  1879.             {
  1880.                 case LA_Type:
  1881.  
  1882.                     type = Entry -> ti_Data;
  1883.  
  1884.                     if(type == END_KIND)
  1885.                     {
  1886.                         handle -> CurrentGroup = handle -> CurrentGroup -> Special . Group . ParentGroup;
  1887.  
  1888.                         return;
  1889.                     }
  1890.  
  1891.                     break;
  1892.  
  1893.                 case LA_ID:
  1894.  
  1895.                     id = Entry -> ti_Data;
  1896.                     break;
  1897.  
  1898.                 case LA_LabelID:
  1899.  
  1900.                     if(handle -> LocaleHook)
  1901.                         label = (STRPTR)CallHookPkt(handle -> LocaleHook,handle,(APTR)Entry -> ti_Data);
  1902.                     else
  1903.                     {
  1904.                         handle -> Failed = TRUE;
  1905.  
  1906.                         return;
  1907.                     }
  1908.  
  1909.                     break;
  1910.  
  1911.                 case LA_LabelText:
  1912.  
  1913.                     label = (STRPTR)Entry -> ti_Data;
  1914.                     break;
  1915.             }
  1916.         }
  1917.  
  1918.         if(type >= GENERIC_KIND)
  1919.             LT_AddA(handle,type,label,id,tagList);
  1920.         else
  1921.             handle -> Failed = TRUE;
  1922.     }
  1923. }
  1924.  
  1925.  
  1926. /*****************************************************************************/
  1927.  
  1928.  
  1929. VOID LIBENT
  1930. LT_EndGroup(REG(a0) LayoutHandle *handle)
  1931. {
  1932.     if(handle && !handle -> Failed)
  1933.         handle -> CurrentGroup = handle -> CurrentGroup -> Special . Group . ParentGroup;
  1934. }
  1935.